home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / Python 1.4 source / Extensions / img / imgsgimodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-23  |  24.2 KB  |  1,063 lines  |  [TEXT/CWIE]
  1. /***********************************************************
  2. Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
  3. Amsterdam, The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* rgb objects */
  26.  
  27. #include "Python.h"
  28. #include "import.h"
  29.  
  30. static PyObject *format_rgb, *format_rgb_b2t, *format_rgb_choices;
  31. static PyObject *format_grey, *format_grey_b2t, *format_xgrey,
  32.         *format_xgrey_b2t, *format_grey_choices;
  33. static PyObject *format_rgb8, *format_rgb8_b2t, *format_xrgb8,
  34.         *format_xrgb8_b2t, *format_rgb8_choices;
  35. static PyObject *format_choices;
  36.  
  37. #define is_4bytefmt(fmt)    (fmt==format_rgb||fmt==format_rgb_b2t)
  38. #define is_alignfmt(fmt)    (fmt==format_grey||fmt==format_grey_b2t||\
  39.                  fmt==format_rgb8||fmt==format_rgb8_b2t)
  40. #define is_b2tfmt(fmt)        (fmt==format_grey_b2t||fmt==format_xgrey_b2t||\
  41.                  fmt==format_rgb8_b2t||fmt==format_xrgb8_b2t||\
  42.                  fmt==format_rgb_b2t)
  43. #define is_ditherfmt(fmt)    (fmt==format_rgb8||fmt==format_rgb8_b2t||\
  44.                  fmt==format_xrgb8||fmt==format_xrgb8_b2t)
  45. #define is_greyfmt(fmt)        (fmt==format_grey||fmt==format_grey_b2t||\
  46.                  fmt==format_xgrey||fmt==format_xgrey_b2t)
  47.  
  48. typedef struct {
  49.     PyObject_HEAD
  50.     PyObject    *dict;        /* Attributes dictionary */
  51.     int    is_reader;    /* TRUE if this is a reader */
  52.     char    *filename;    /* filename of the image file */
  53.     FILE    *filep;
  54.     int    width, height;
  55.     int    nchannels;
  56.     int    rle;
  57.     int    colormapID;
  58. } rgbobject;
  59.  
  60. static PyObject *errobject;
  61.  
  62. staticforward PyTypeObject Rgbtype;
  63.  
  64. #define is_rgbobject(v)        ((v)->ob_type == &Rgbtype)
  65.  
  66. static char doc_rgb[] =
  67.     "This object can be used to read/write RGB image files.\n"
  68.     "The 'width', 'height' and 'format' attributes give info about the\n"
  69.     "image data read (or to be written)";
  70.  
  71. /* Routine to easily obtain C data from the dict python data */
  72. int
  73. rgbselfattr(self, name, fmt, ptr, wanterr)
  74.     rgbobject *self;
  75.     char *name;
  76.     char *fmt;
  77.     void *ptr;
  78.     int wanterr;
  79. {
  80.     PyObject *obj;
  81.     char errbuf[100];
  82.  
  83.     obj = PyDict_GetItemString(self->dict, name);
  84.     if (obj == NULL) {
  85.         if (wanterr) {
  86.             sprintf(errbuf, "Required attribute '%s' not set", name);
  87.             PyErr_SetString(errobject, errbuf);
  88.             return 0;
  89.         } else {
  90.             PyErr_Clear();
  91.             return 0;
  92.         }
  93.     }
  94.     if (!PyArg_Parse(obj, fmt, ptr)) {
  95.         if (!wanterr)
  96.             PyErr_Clear();
  97.         return 0;
  98.     }
  99.     return 1;
  100. }
  101.  
  102. /* Routine to easily insert integer into dictionary */
  103. rgbsetintattr(self, name, value)
  104.     rgbobject *self;
  105.     char *name;
  106.     int value;
  107. {
  108.     PyObject *obj;
  109.     int rv;
  110.  
  111.     obj = PyInt_FromLong(value);
  112.     rv = PyDict_SetItemString(self->dict, name, obj);
  113.     Py_DECREF(obj);
  114.     return rv;
  115. }
  116.  
  117. static rgbobject *
  118. newrgbobject()
  119. {
  120.     rgbobject *xp;
  121.     xp = PyObject_NEW(rgbobject, &Rgbtype);
  122.     if (xp == NULL)
  123.         return NULL;
  124.     xp->dict = PyDict_New();
  125.     xp->filename = NULL;
  126.     xp->filep = NULL;
  127.     return xp;
  128. }
  129.  
  130. static int
  131. RGBreadheader(self)
  132.     rgbobject *self;
  133. {
  134.     unsigned char header[512];
  135.     int dimension;
  136.  
  137.     /*
  138.        The RGB header looks as follows:
  139.        2 bytes    IRIS image file magic number
  140.        1 byte    storage format
  141.        1 byte    number of bytes per pixel channel
  142.        2 bytes    number of dimensions
  143.        2 bytes    x size in pixels
  144.        2 bytes    y size in pixels
  145.        2 bytes    number of channels
  146.        4 bytes    minimum pixel value
  147.        4 bytes    maximum pixel value
  148.        4 bytes    ignored
  149.        80 bytes    image name
  150.        4 bytes    colormap ID
  151.        404 bytes    ignored
  152.      */
  153.     if (fread(header, 1, 512, self->filep) != 512) {
  154.         PyErr_SetString(errobject, "Truncated RGB file");
  155.         return 0;
  156.     }
  157.     if ((header[0]<<8|header[1]) != 474) {
  158.         PyErr_SetString(errobject, "Not an RGB file");
  159.         return 0;
  160.     }
  161.     self->rle = header[2];
  162.     if (self->rle != 0 && self->rle != 1)
  163.         goto BadRGB;
  164.     if (header[3] != 1)    /* only support 1 byte per pixel */
  165.         goto BadRGB;
  166.     dimension = header[4]<<8|header[5];
  167.     if (dimension < 1 || dimension > 3)
  168.         goto BadRGB;
  169.     self->width = header[6]<<8|header[7];
  170.     self->height = header[8]<<8|header[9];
  171.     rgbsetintattr(self, "width", self->width);
  172.     rgbsetintattr(self, "height", self->height);
  173.     self->nchannels = header[10]<<8|header[11];
  174.     if (self->nchannels != 1 && self->nchannels != 3 && self->nchannels != 4)
  175.         goto BadRGB;
  176.     if (dimension == 1) {
  177.         if (self->height != 1 || self->nchannels != 1)
  178.             goto BadRGB;
  179.     } else if (dimension == 2) {
  180.         if (self->nchannels != 1)
  181.             goto BadRGB;
  182.     }
  183.     /*
  184.     self->pinmin = header[12]<<24|header[13]<<16|header[14]<<8|header[15];
  185.     self->pinmax = header[16]<<24|header[17]<<16|header[18]<<8|header[19];
  186.     */
  187.     if (header[20]) {
  188.         PyObject *obj;
  189.         int rv;
  190.         header[99] = 0;    /* just to be sure... */
  191.         obj = PyString_FromString((char *)header+20);
  192.         rv = PyDict_SetItemString(self->dict, "name", obj);
  193.         Py_XDECREF(obj);
  194.     }
  195.     self->colormapID = header[104]<<24|header[105]<<16|
  196.                header[106]<<8|header[107];
  197.     if (self->colormapID == 1) {
  198.         if (self->nchannels != 1)
  199.             goto BadRGB;
  200.         PyDict_SetItemString(self->dict, "format", format_rgb8);
  201.         PyDict_SetItemString(self->dict, "format_choices",
  202.                      format_rgb8_choices);
  203.         return 1;
  204.     } else if (self->colormapID != 0)
  205.         goto BadRGB;
  206.     if (self->nchannels == 1) {
  207.         PyDict_SetItemString(self->dict, "format", format_grey);
  208.         PyDict_SetItemString(self->dict, "format_choices",
  209.                      format_grey_choices);
  210.     } else {
  211.         PyDict_SetItemString(self->dict, "format", format_rgb);
  212.         PyDict_SetItemString(self->dict, "format_choices",
  213.                      format_rgb_choices);
  214.     }
  215.     return 1;
  216.  
  217.   BadRGB:
  218.     PyErr_SetString(errobject, "Illegal or unsupported RGB file");
  219.     return 0;
  220. }
  221.  
  222. static int
  223. initrgbreader(self, name)
  224.     rgbobject *self;
  225.     char *name;
  226. {
  227.     char *name_copy;
  228.  
  229.     if ((name_copy = malloc(strlen(name)+1)) == NULL) {
  230.         PyErr_NoMemory();
  231.         return 0;
  232.     }
  233.     strcpy(name_copy, name);
  234.     self->filename = name_copy;
  235.     self->is_reader = 1;
  236.     self->filep = fopen(name, "rb");
  237.     if (self->filep == NULL) {
  238.         PyErr_SetFromErrno(PyExc_IOError);
  239.         return 0;
  240.     }
  241.     if (!RGBreadheader(self))
  242.         return 0;
  243.     if (PyErr_Occurred())
  244.         return 0;
  245.     return 1;
  246. }
  247.  
  248. static int
  249. initrgbwriter(self, name)
  250.     rgbobject *self;
  251.     char *name;
  252. {
  253.     char *name_copy;
  254.  
  255.     if ((name_copy = malloc(strlen(name)+1)) == NULL) {
  256.         PyErr_NoMemory();
  257.         return 0;
  258.     }
  259.     strcpy(name_copy, name);
  260.     self->filename = name_copy;
  261.     self->is_reader = 0;
  262.     PyDict_SetItemString(self->dict, "format", format_rgb);
  263.     PyDict_SetItemString(self->dict, "format_choices", format_choices);
  264.     if (PyErr_Occurred())
  265.         return 0;
  266.     return 1;
  267. }
  268.  
  269. /* rgb methods */
  270.  
  271. static void
  272. rgb_dealloc(xp)
  273.     rgbobject *xp;
  274. {
  275.     Py_XDECREF(xp->dict);
  276.     if (xp->filename)
  277.         free(xp->filename);
  278.     if (xp->filep)
  279.         fclose(xp->filep);
  280.     PyMem_DEL(xp);
  281. }
  282.  
  283. static PyObject *
  284. RGBreadimage(self, fmt)
  285.     rgbobject *self;
  286.     PyObject *fmt;
  287. {
  288.     int x, y, z;
  289.     int v;
  290.     PyObject *rv;
  291.     char *ptr;
  292.     int xstride, ystride, zstride;
  293.  
  294.     x = self->width;
  295.     y = self->height;
  296.     z = self->nchannels;
  297.     if (z == 1) {
  298.         if (is_alignfmt(fmt))
  299.             x = (x + 3) & ~3;
  300.         rv = PyString_FromStringAndSize(NULL, x * y);
  301.         if (rv == NULL)
  302.             return NULL;
  303.         ptr = PyString_AS_STRING((PyStringObject *) rv);
  304.         memset(ptr, 0, x * y);
  305.         if (is_b2tfmt(fmt)) {
  306.             ystride = x;
  307.         } else {
  308.             ptr += x * (y - 1);
  309.             ystride = -x;
  310.         }
  311.         ystride -= self->width;
  312.         zstride = 0;
  313.         xstride = 1;
  314.     } else {
  315.         rv = PyString_FromStringAndSize(NULL, x * y * 4);
  316.         if (rv == NULL)
  317.             return NULL;
  318.         ptr = PyString_AS_STRING((PyStringObject *) rv);
  319.         memset(ptr, 0, x * y * 4);
  320.         if (is_b2tfmt(fmt)) {
  321.             ystride = x * 4;
  322.         } else {
  323.             ptr += x * (y - 1) * 4;
  324.             ystride = -x * 4;
  325.         }
  326.         ptr += 3;
  327.         zstride = -ystride * y - 1;
  328.         ystride -= x * 4;
  329.         xstride = 4;
  330.     }
  331.     for (z = self->nchannels; z > 0; z--) {
  332.         for (y = self->height; y > 0; y--) {
  333.             for (x = self->width; x > 0; x--) {
  334.                 v = getc(self->filep);
  335.                 if (v == EOF) {
  336.                     PyErr_SetString(errobject,
  337.                             "Truncated RGB file");
  338.                     Py_DECREF(rv);
  339.                     return NULL;
  340.                 }
  341.                 *ptr = v;
  342.                 ptr += xstride;
  343.             }
  344.             ptr += ystride;
  345.         }
  346.         ptr += zstride;
  347.     }
  348.     return rv;
  349. }
  350.  
  351. static int
  352. readtab(filep, tab, len)
  353.     FILE *filep;
  354.     unsigned long *tab;
  355.     int len;
  356. {
  357.     int ch;
  358.     unsigned long v;
  359.     int i;
  360.  
  361.     while (--len >= 0) {
  362.         v = 0;
  363.         for (i = 4; i > 0; i--) {
  364.             if ((ch = getc(filep)) == EOF) {
  365.                 PyErr_SetString(errobject,
  366.                         "Truncated RGB file");
  367.                 return 0;
  368.             }
  369.             v = v << 8 | ch;
  370.         }
  371.         *tab++ = v;
  372.     }
  373.     return 1;
  374. }
  375.  
  376. static int
  377. writetab(filep, tab, len)
  378.     FILE *filep;
  379.     unsigned long *tab;
  380.     int len;
  381. {
  382.     unsigned long v;
  383.     int i;
  384.  
  385.     while (--len >= 0) {
  386.         v = *tab++;
  387.         for (i = 4; i > 0; i--) {
  388.             putc(v >> 24, filep);
  389.             v <<= 8;
  390.         }
  391.     }
  392.     if (ferror(filep))
  393.         return 0;
  394.     return 1;
  395. }
  396.  
  397. static int
  398. compare(p1, p2)
  399.     const void *p1, *p2;
  400. {
  401.     return ** (const unsigned long **) p1 - ** (const unsigned long **) p2;
  402. }
  403.  
  404. static PyObject *
  405. RGBreadrleimage(self, fmt)
  406.     rgbobject *self;
  407.     PyObject *fmt;
  408. {
  409.     int tablen = self->height * self->nchannels;
  410.     unsigned long *starttab = malloc(tablen * sizeof(unsigned long));
  411.     unsigned long *lengthtab = malloc(tablen * sizeof(unsigned long));
  412.     unsigned long **sorttab = malloc(tablen * sizeof(unsigned long *));
  413.     unsigned long **sorttab_ptr;
  414.     unsigned long seek_ptr, seek_pos;
  415.     int i, prev_row;
  416.     int width, n, y, z, stride;
  417.     PyObject *rv;
  418.     unsigned char *ptr, *optr, *cptr;
  419.     int reverse;
  420.  
  421.     if (starttab == NULL || lengthtab == NULL || sorttab == NULL) {
  422.         PyErr_NoMemory();
  423.         goto ErrorExit;
  424.     }
  425.     if (!readtab(self->filep, starttab, tablen))
  426.         goto ErrorExit;
  427.     if (!readtab(self->filep, lengthtab, tablen))
  428.         goto ErrorExit;
  429.     for (i = 0; i < tablen; i++)
  430.         sorttab[i] = &starttab[i];
  431.     qsort(sorttab, tablen, sizeof(unsigned long *), compare);
  432.     sorttab_ptr = sorttab;
  433.  
  434.     width = self->width;
  435.     if (self->nchannels == 1) {
  436.         if (is_alignfmt(fmt))
  437.             width = (width + 3) & ~3;
  438.         stride = 1;
  439.     } else {
  440.         stride = 4;
  441.         width *= 4;
  442.     }
  443.     if (!is_b2tfmt(fmt)) {
  444.         /* If height > 1, the following is still != 0, and it
  445.                    is very handy to have this number floating around
  446.                    when we have to reverse the image.  If height == 0
  447.                    or 1 it doesn't matter whether we reverse or not */
  448.         reverse = width * (self->height - 1);
  449.     } else
  450.         reverse = 0;
  451.     rv = PyString_FromStringAndSize(NULL, width * self->height);
  452.     if (rv == NULL)
  453.         goto ErrorExit;
  454.     ptr = (unsigned char *)PyString_AS_STRING((PyStringObject *) rv);
  455.     memset(ptr, 0, width * self->height);
  456.  
  457.     prev_row = -1;
  458.     seek_pos = 512 + 2 * tablen * 4;
  459.     while (--tablen >= 0) {
  460.         i = *sorttab_ptr++ - starttab;
  461.         seek_ptr = starttab[i];
  462.         if (seek_ptr == prev_row) {
  463.             /* copy a row */
  464.             if (reverse) {
  465.                 cptr = ptr + reverse - y * width;
  466.                 optr = ptr + reverse - (i%self->height)*width;
  467.             } else {
  468.                 cptr = ptr + y * width;
  469.                 optr = ptr + (i % self->height) * width;
  470.             }
  471.             cptr += stride - z - 1;
  472.             optr += stride - (i / self->height) - 1;
  473.             n = self->width;
  474.             while (--n >= 0) {
  475.                 *optr = *cptr;
  476.                 optr += stride;
  477.                 cptr += stride;
  478.             }
  479.             continue;
  480.         }
  481.         if (seek_pos != seek_ptr) {
  482.             while (seek_pos < seek_ptr) {
  483.                 if ((n = getc(self->filep)) == EOF)
  484.                     goto EOFError;
  485.                 seek_pos++;
  486.             }
  487.             if (seek_pos > seek_ptr) {
  488.                 PyErr_SetString(errobject, "Bad rle table");
  489.                 goto ErrorExit;
  490.             }
  491.         }
  492.         z = i / self->height;
  493.         y = i % self->height;
  494.         if (reverse)
  495.             optr = ptr + reverse - y * width;
  496.         else
  497.             optr = ptr + y * width;
  498.         optr += stride - z - 1;
  499.         for (;;) {
  500.             int pixel, count;
  501.             if ((pixel = getc(self->filep)) == EOF)
  502.                 goto EOFError;
  503.             seek_pos++;
  504.             if (!(count = (pixel & 0x7f)))
  505.                 break;
  506.             if (pixel & 0x80) {
  507.                 while (count--) {
  508.                     if ((pixel = getc(self->filep)) == EOF)
  509.                         goto EOFError;
  510.                     seek_pos++;
  511.                     *optr = pixel;
  512.                     optr += stride;
  513.                 }
  514.             } else {
  515.                 if ((pixel = getc(self->filep)) == EOF)
  516.                     goto EOFError;
  517.                 seek_pos++;
  518.                 while (count--) {
  519.                     *optr = pixel;
  520.                     optr += stride;
  521.                 }
  522.             }
  523.         }
  524.         prev_row = seek_ptr;
  525.     }
  526.  
  527.     free(starttab);
  528.     free(lengthtab);
  529.     free(sorttab);
  530.     return rv;
  531.  
  532.   EOFError:
  533.     PyErr_SetString(errobject, "Truncated RGB file");
  534.   ErrorExit:
  535.     if (starttab)
  536.         free(starttab);
  537.     if (lengthtab)
  538.         free(lengthtab);
  539.     if (sorttab)
  540.         free(sorttab);
  541.     return NULL;
  542. }
  543.  
  544. static char doc_read[] = "Read the actual image data as a string.";
  545.  
  546. static PyObject *
  547. rgb_read(self, args)
  548.     rgbobject *self;
  549.     PyObject *args;
  550. {
  551.         PyObject *fmt;
  552.     
  553.     if (!PyArg_ParseTuple(args,""))
  554.         return NULL;
  555.     if (!self->is_reader) {
  556.         PyErr_SetString(errobject, "Cannot read() from writer object");
  557.         return NULL;
  558.     }
  559.     /* Get format (and other args), check, read data, return it */
  560.     if (!rgbselfattr(self, "format", "O", &fmt, 1))
  561.         return NULL;
  562.     if (self->nchannels == 1) {
  563.         if (self->colormapID == 0) {
  564.             if (!is_greyfmt(fmt))
  565.                 goto illegal_format;
  566.         } else {
  567.             /* self->colormapID == 1 */
  568.             if (!is_ditherfmt(fmt))
  569.                 goto illegal_format;
  570.         }
  571.     } else {
  572.         if (!is_4bytefmt(fmt))
  573.             goto illegal_format;
  574.     }
  575.     if (self->rle)
  576.         return RGBreadrleimage(self, fmt);
  577.     else
  578.         return RGBreadimage(self, fmt);
  579.  
  580.   illegal_format:
  581.     PyErr_SetString(errobject, "Illegal format");
  582.     return NULL;
  583. }
  584.  
  585. #define putbyte(p,x)    ((p)[0]=(x))
  586. #define putshort(p,x)    ((p)[0]=(x)>>8,(p)[1]=(x))
  587. #define putlong(p,x) ((p)[0]=(x)>>24,(p)[1]=(x)>>16,(p)[2]=(x)>>8,(p)[3]=(x))
  588.  
  589. static int
  590. RGBwriteheader(self, fmt)
  591.     rgbobject *self;
  592.     PyObject *fmt;
  593. {
  594.     char *name;
  595.     char header[512];
  596.  
  597.     memset(header, 0, 512);
  598.     putshort(header+0, 474);
  599.     putbyte(header+2, self->rle);
  600.     putbyte(header+3, 1);
  601.     if (self->nchannels == 1)
  602.         if (self->height == 1)
  603.             putshort(header+4, 1);
  604.         else
  605.             putshort(header+4, 2);
  606.     else
  607.         putshort(header+4, 3);
  608.     putshort(header+6, self->width);
  609.     putshort(header+8, self->height);
  610.     putshort(header+10, self->nchannels);
  611.     putlong(header+12, 0);
  612.     putlong(header+16, 255);
  613.     if (!rgbselfattr(self, "name", "s", &name, 0))
  614.         name = "no name";
  615.     strncpy(header+24, name, 79);
  616.     if (is_ditherfmt(fmt))
  617.         putlong(header+104, 1);
  618.     else
  619.         putlong(header+104, 0);
  620.     if (fwrite(header, 1, 512, self->filep) != 512) {
  621.         PyErr_SetFromErrno(PyExc_IOError);
  622.         return 0;
  623.     }
  624.     return 1;
  625. }
  626.  
  627. static PyObject *
  628. RGBwriteimage(self, fmt, ptr)
  629.     rgbobject *self;
  630.     PyObject *fmt;
  631.     unsigned char *ptr;
  632. {
  633.     int x, y, z;
  634.     int xstride, ystride, zstride;
  635.  
  636.     x = self->width;
  637.     y = self->height;
  638.     z = self->nchannels;
  639.     if (z == 1) {
  640.         if (is_alignfmt(fmt))
  641.             x = (x + 3) & ~3;
  642.         if (is_b2tfmt(fmt)) {
  643.             ystride = x;
  644.         } else {
  645.             ptr += x * (y - 1);
  646.             ystride = -x;
  647.         }
  648.         ystride -= self->width;
  649.         zstride = 0;
  650.         xstride = 1;
  651.     } else {
  652.         if (is_b2tfmt(fmt)) {
  653.             ystride = x * 4;
  654.         } else {
  655.             ptr += x * (y - 1) * 4;
  656.             ystride = -x * 4;
  657.         }
  658.         ptr += 3;
  659.         zstride = -ystride * y - 1;
  660.         ystride -= x * 4;
  661.         xstride = 4;
  662.     }
  663.     for (z = self->nchannels; z > 0; z--) {
  664.         for (y = self->height; y > 0; y--) {
  665.             for (x = self->width; x > 0; x--) {
  666.                 putc(*ptr, self->filep);
  667.                 ptr += xstride;
  668.             }
  669.             ptr += ystride;
  670.         }
  671.         ptr += zstride;
  672.     }
  673.  
  674.     fflush(self->filep);
  675.  
  676.     Py_INCREF(Py_None);
  677.     return Py_None;
  678. }
  679.  
  680. static int
  681. compressrow(iptr, rlebuf, length, stride)
  682.     unsigned char *iptr;
  683.     unsigned char *rlebuf;
  684.     int length, stride;
  685. {
  686.     unsigned char *ibufend = iptr + length * stride;
  687.     unsigned char *optr = rlebuf;
  688.     unsigned char *sptr;
  689.     int stride2 = 2 * stride;
  690.     int count, todo, cc;
  691.  
  692.     while (iptr < ibufend) {
  693.         sptr = iptr;
  694.         iptr += stride2;
  695.         while (iptr < ibufend && (iptr[-stride2] != iptr[-stride] ||
  696.                       iptr[-stride] != iptr[0]))
  697.             iptr += stride;
  698.         iptr -= stride2;
  699.         count = (iptr - sptr) / stride;
  700.         while (count) {
  701.             todo = count > 126 ? 126 : count;
  702.             count -= todo;
  703.             *optr++ = 0x80 | todo;
  704.             while (--todo >= 0) {
  705.                 *optr++ = *sptr;
  706.                 sptr += stride;
  707.             }
  708.         }
  709.         sptr = iptr;
  710.         cc = *iptr;
  711.         iptr += stride;
  712.         while (iptr < ibufend && *iptr == cc)
  713.             iptr += stride;
  714.         count = (iptr - sptr) / stride;
  715.         while (count) {
  716.             todo = count > 126 ? 126 : count;
  717.             count -= todo;
  718.             *optr++ = todo;
  719.             *optr++ = cc;
  720.         }
  721.     }
  722.     *optr++ = 0;
  723.     return optr - rlebuf;
  724. }
  725.  
  726. static PyObject *
  727. RGBwriterleimage(self, fmt, ptr)
  728.     rgbobject *self;
  729.     PyObject *fmt;
  730.     unsigned char *ptr;
  731. {
  732.     unsigned char *rlebuf;
  733.     unsigned long *starttab, *lengthtab;
  734.     long pos;
  735.     int tablen, rlebuflen, len;
  736.     int i, y, z;
  737.     int xsize, ysize, zsize, xstride, ystride;
  738.  
  739.     xsize = ystride = self->width;
  740.     ysize = self->height;
  741.     zsize = self->nchannels;
  742.     tablen = ysize * zsize;
  743.     rlebuflen = 1.05 * xsize + 10;
  744.     starttab = (unsigned long *) malloc(tablen * sizeof(unsigned long));
  745.     lengthtab = (unsigned long *) malloc(tablen * sizeof(unsigned long));
  746.     rlebuf = (unsigned char *) malloc(rlebuflen);
  747.  
  748.     if (starttab == NULL || lengthtab == NULL || rlebuf == NULL) {
  749.         PyErr_NoMemory();
  750.         goto ErrorExit;
  751.     }
  752.     if (zsize == 1) {
  753.         if (is_alignfmt(fmt))
  754.             ystride = (ystride + 3) & ~3;
  755.         xstride = 1;
  756.     } else {
  757.         xstride = 4;
  758.         ystride *= 4;
  759.         ptr += 3;
  760.     }
  761.     if (!is_b2tfmt(fmt)) {
  762.         ptr += ystride * (ysize - 1);
  763.         ystride = -ystride;
  764.     }
  765.     ystride += zsize;
  766.  
  767.     pos = 512 + 2 * tablen * 4;
  768.     if (fseek(self->filep, pos, SEEK_SET))
  769.         goto WriteError;
  770.     i = 0;
  771.     for (y = ysize; y > 0; y--) {
  772.         for (z = zsize; z > 0; z--) {
  773.             len = compressrow(ptr, rlebuf, xsize, xstride);
  774.             if (len > rlebuflen) {
  775.                 PyErr_SetString(errobject,
  776.                     "rlebuf is too small - bad poop");
  777.                 goto ErrorExit;
  778.             }
  779.             starttab[i] = pos;
  780.             lengthtab[i] = len;
  781.             if (fwrite(rlebuf, 1, len, self->filep) != len)
  782.                 goto WriteError;
  783.             pos += len;
  784.             ptr--;
  785.             i += ysize;
  786.         }
  787.         ptr += ystride;
  788.         i += 1 - tablen;
  789.     }
  790.  
  791.     if (fseek(self->filep, 512, SEEK_SET))
  792.         goto WriteError;
  793.     if (!writetab(self->filep, starttab, tablen))
  794.         goto WriteError;
  795.     if (!writetab(self->filep, lengthtab, tablen))
  796.         goto WriteError;
  797.     fseek(self->filep, 0, SEEK_END);
  798.     fflush(self->filep);
  799.  
  800.     free(starttab);
  801.     free(lengthtab);
  802.     free(rlebuf);
  803.  
  804.     Py_INCREF(Py_None);
  805.     return Py_None;
  806.  
  807.   WriteError:
  808.     PyErr_SetString(errobject, "Error writing RGB file");
  809.  
  810.   ErrorExit:
  811.     if (starttab)
  812.         free(starttab);
  813.     if (lengthtab)
  814.         free(lengthtab);
  815.     if (rlebuf)
  816.         free(rlebuf);
  817.     return NULL;
  818. }
  819.  
  820.  
  821. static char doc_write[] = "Write the image data.";
  822.  
  823. static PyObject *
  824. rgb_write(self, args)
  825.     rgbobject *self;
  826.     PyObject *args;
  827. {
  828.         unsigned char *data;
  829.     int datalen;
  830.     int i, width;
  831.     PyObject *fmt;
  832.     
  833.     if (!PyArg_ParseTuple(args, "s#", &data, &datalen))
  834.         return NULL;
  835.     if (self->is_reader) {
  836.         PyErr_SetString(errobject, "Cannot write() to reader object");
  837.         return NULL;
  838.     }
  839.     if (!rgbselfattr(self, "width", "i", &self->width, 1) ||
  840.         !rgbselfattr(self, "height", "i", &self->height, 1) ||
  841.         !rgbselfattr(self, "format", "O", &fmt, 1))
  842.         return NULL;
  843.     if (is_4bytefmt(fmt)) {
  844.         if (!rgbselfattr(self, "rgba", "i", &i, 0))
  845.             i = 0;
  846.         if (i)
  847.             self->nchannels = 4;
  848.         else
  849.             self->nchannels = 3;
  850.         self->colormapID = 0;
  851.         i = 4;
  852.     } else {
  853.         self->nchannels = 1;
  854.         if (is_ditherfmt(fmt))
  855.             self->colormapID = 1;
  856.         else
  857.             self->colormapID = 0;
  858.         i = 1;
  859.     }
  860.     width = self->width;
  861.     if (is_alignfmt(fmt))
  862.         width = (width + 3) & ~3;
  863.     if (width * self->height * i != datalen) {
  864.         PyErr_SetString(errobject, "Incorrect datasize");
  865.         return NULL;
  866.     }
  867.     self->filep = fopen(self->filename, "wb");
  868.     if (self->filep == NULL) {
  869.         PyErr_SetFromErrno(PyExc_IOError);
  870.         return NULL;
  871.     }
  872.  
  873.     if (!rgbselfattr(self, "rle", "i", &self->rle, 0))
  874.         self->rle = 1;
  875.  
  876.     if (!RGBwriteheader(self, fmt))
  877.         return NULL;
  878.  
  879.     if (self->rle)
  880.         return RGBwriterleimage(self, fmt, data);
  881.     else
  882.         return RGBwriteimage(self, fmt, data);
  883. }
  884.  
  885. static struct PyMethodDef rgb_methods[] = {
  886.     {"read",    (PyCFunction)rgb_read,    1,    doc_read},
  887.     {"write",    (PyCFunction)rgb_write,    1,    doc_write},
  888.     {NULL,        NULL}        /* sentinel */
  889. };
  890.  
  891. static PyObject *
  892. rgb_getattr(xp, name)
  893.     rgbobject *xp;
  894.     char *name;
  895. {
  896.         PyObject *v;
  897.     
  898.     if (xp->dict != NULL) {
  899.             if (strcmp(name, "__dict__") == 0) {
  900.                 Py_INCREF(xp->dict);
  901.             return xp->dict;
  902.         }
  903.         if (strcmp(name, "__doc__") == 0) {
  904.                 return PyString_FromString(doc_rgb);
  905.         }
  906.         v = PyDict_GetItemString(xp->dict, name);
  907.         if (v != NULL) {
  908.             Py_INCREF(v);
  909.             return v;
  910.         }
  911.     }
  912.     return Py_FindMethod(rgb_methods, (PyObject *)xp, name);
  913. }
  914.  
  915. static int
  916. rgb_setattr(xp, name, v)
  917.     rgbobject *xp;
  918.     char *name;
  919.     PyObject *v;
  920. {
  921.     if (xp->dict == NULL) {
  922.         xp->dict = PyDict_New();
  923.         if (xp->dict == NULL)
  924.             return -1;
  925.     }
  926.     if (v == NULL) {
  927.         int rv = PyDict_DelItemString(xp->dict, name);
  928.         if (rv < 0)
  929.             PyErr_SetString(PyExc_AttributeError,
  930.                     "delete non-existing imgrgb attribute");
  931.         return rv;
  932.     }
  933.     else
  934.         return PyDict_SetItemString(xp->dict, name, v);
  935. }
  936.  
  937. static PyTypeObject Rgbtype = {
  938.     PyObject_HEAD_INIT(&PyType_Type)
  939.     0,            /*ob_size*/
  940.     "imgrgb",        /*tp_name*/
  941.     sizeof(rgbobject),    /*tp_basicsize*/
  942.     0,            /*tp_itemsize*/
  943.     /* methods */
  944.     (destructor)rgb_dealloc, /*tp_dealloc*/
  945.     0,            /*tp_print*/
  946.     (getattrfunc)rgb_getattr, /*tp_getattr*/
  947.     (setattrfunc)rgb_setattr, /*tp_setattr*/
  948.     0,            /*tp_compare*/
  949.     0,            /*tp_repr*/
  950.     0,            /*tp_as_number*/
  951.     0,            /*tp_as_sequence*/
  952.     0,            /*tp_as_mapping*/
  953.     0,            /*tp_hash*/
  954. };
  955.  
  956. static char doc_newreader[] = "Create reader for file passed as arg.";
  957.  
  958. static PyObject *
  959. rgb_newreader(self, args)
  960.     PyObject *self;
  961.     PyObject *args;
  962. {
  963.         char *filename;
  964.     rgbobject *obj;
  965.     
  966.     if (!PyArg_ParseTuple(args, "s", &filename))
  967.         return NULL;
  968.     if ((obj = newrgbobject()) == NULL)
  969.         return NULL;
  970.     if (!initrgbreader(obj, filename)) {
  971.         rgb_dealloc(obj);
  972.         return NULL;
  973.     }
  974.     return (PyObject *)obj;
  975. }
  976.  
  977. static char doc_newwriter[] = "Create writer for file passed as arg.";
  978.  
  979. static PyObject *
  980. rgb_newwriter(self, args)
  981.     PyObject *self;
  982.     PyObject *args;
  983. {
  984.         char *filename;
  985.     rgbobject *obj;
  986.     
  987.     if (!PyArg_ParseTuple(args, "s", &filename))
  988.         return NULL;
  989.     if ((obj = newrgbobject()) == NULL)
  990.         return NULL;
  991.     if (!initrgbwriter(obj, filename)) {
  992.         rgb_dealloc(obj);
  993.         return NULL;
  994.     }
  995.     return (PyObject *)obj;
  996. }
  997.  
  998.  
  999. /* List of functions defined in the module */
  1000.  
  1001. static struct PyMethodDef rgb_module_methods[] = {
  1002.     {"reader",    rgb_newreader,    1,    doc_newreader},
  1003.     {"writer",    rgb_newwriter,    1,    doc_newwriter},
  1004.     {NULL,        NULL}        /* sentinel */
  1005. };
  1006.  
  1007.  
  1008. /* Initialization function for the module (*must* be called initimgrgb) */
  1009. static char doc_imgrgb[] = "Module that reads and writes RGB image files.";
  1010.  
  1011. void
  1012. initimgsgi()
  1013. {
  1014.     PyObject *m, *d, *x, *formatmodule, *formatdict;
  1015.  
  1016.     /* Create the module and add the functions */
  1017.     m = Py_InitModule("imgsgi", rgb_module_methods);
  1018.  
  1019.     /* Add some symbolic constants to the module */
  1020.     d = PyModule_GetDict(m);
  1021.     errobject = PyString_FromString("imgsgi.error");
  1022.     PyDict_SetItemString(d, "error", errobject);
  1023.     x = PyString_FromString(doc_imgrgb);
  1024.     PyDict_SetItemString(d, "__doc__", x);
  1025.  
  1026.     /* Get supported formats */
  1027.     if ((formatmodule = PyImport_ImportModule("imgformat")) == NULL)
  1028.         Py_FatalError("imgsgi depends on imgformat");
  1029.     if ((formatdict = PyModule_GetDict(formatmodule)) == NULL)
  1030.         Py_FatalError("imgformat has no dict");
  1031.  
  1032.     format_rgb = PyDict_GetItemString(formatdict,"rgb");
  1033.     format_rgb_b2t = PyDict_GetItemString(formatdict,"rgb_b2t");
  1034.     format_rgb_choices = Py_BuildValue("(OO)", format_rgb, format_rgb_b2t);
  1035.  
  1036.     format_grey = PyDict_GetItemString(formatdict,"grey");
  1037.     format_grey_b2t = PyDict_GetItemString(formatdict,"grey_b2t");
  1038.     format_xgrey = PyDict_GetItemString(formatdict,"xgrey");
  1039.     format_xgrey_b2t = PyDict_GetItemString(formatdict,"xgrey_b2t");
  1040.     format_grey_choices = Py_BuildValue("(OOOO)",
  1041.                         format_grey, format_grey_b2t,
  1042.                         format_xgrey, format_xgrey_b2t);
  1043.  
  1044.     format_rgb8 = PyDict_GetItemString(formatdict,"rgb8");
  1045.     format_rgb8_b2t = PyDict_GetItemString(formatdict,"rgb8_b2t");
  1046.     format_xrgb8 = PyDict_GetItemString(formatdict,"xrgb8");
  1047.     format_xrgb8_b2t = PyDict_GetItemString(formatdict,"xrgb8_b2t");
  1048.     format_rgb8_choices = Py_BuildValue("(OOOO)",
  1049.                         format_rgb8, format_rgb8_b2t,
  1050.                         format_xrgb8, format_xrgb8_b2t);
  1051.  
  1052.     format_choices = Py_BuildValue("(OOOOOOOOOO)",
  1053.                        format_rgb, format_rgb_b2t,
  1054.                        format_grey, format_grey_b2t,
  1055.                        format_xgrey, format_xgrey_b2t,
  1056.                        format_rgb8, format_rgb8_b2t,
  1057.                        format_xrgb8, format_xrgb8_b2t);
  1058.  
  1059.     /* Check for errors */
  1060.     if (PyErr_Occurred())
  1061.         Py_FatalError("can't initialize module imgsgi");
  1062. }
  1063.